home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 1 / Cream of the Crop 1.iso / PROGRAM / DMAKE38B.ARJ / STRING.C < prev    next >
C/C++ Source or Header  |  1992-01-23  |  9KB  |  564 lines
  1. /*
  2.  * (c) Copyright 1990 Conor P. Cahill (uunet!virtech!cpcahil).  
  3.  * You may copy, distribute, and use this software as long as this
  4.  * copyright statement is not removed.
  5.  */
  6.  
  7. #include <stdio.h>
  8. #include <string.h>
  9. #include <sys/types.h>
  10. #include "malloc.h"
  11.  
  12. #ifndef lint
  13. static
  14. char rcs_hdr[] = "$Id: string.c,v 1.1 1992/01/24 03:29:13 dvadura Exp $";
  15. #endif
  16.  
  17. int    malloc_checking = 0;
  18.  
  19. char *
  20. strcat(str1,str2)
  21.     register char    * str1;
  22.     register char    * str2;
  23. {
  24.     char        * rtn;
  25.     int      len;
  26.  
  27.     /* 
  28.      * check pointers agains malloc region.  The malloc* functions
  29.      * will properly handle the case where a pointer does not
  30.      * point into malloc space.
  31.      */
  32.     malloc_checking = 1;
  33.  
  34.     len = strlen(str2);
  35.     malloc_check_str("strcat", str2);
  36.  
  37.     len += strlen(str1) + 1;
  38.     malloc_checking = 0;
  39.  
  40.     malloc_check_data("strcat", str1, len);
  41.  
  42.     rtn = str1;
  43.  
  44.     while( *str1 )
  45.     {
  46.         str1++;
  47.     }
  48.     
  49.     while( (*str1 = *str2) != '\0' )
  50.     {
  51.         str1++;
  52.         str2++;
  53.     }
  54.     
  55.     return(rtn);
  56. }
  57.  
  58. char *
  59. strdup(str1)
  60.     register char    * str1;
  61. {
  62.     char        * malloc();
  63.     char        * rtn;
  64.     register char    * str2;
  65.  
  66.     malloc_check_str("strdup", str1);
  67.  
  68.     rtn = str2 = malloc((unsigned)strlen(str1)+1);
  69.  
  70.     if( rtn != (char *) 0)
  71.     {
  72.         while( (*str2 = *str1) != '\0' )
  73.         {
  74.             str1++;
  75.             str2++;
  76.         }
  77.     }
  78.  
  79.     return(rtn);
  80. }
  81.  
  82. char *
  83. strncat(str1,str2,len)
  84.     register char    * str1;
  85.     register char    * str2;
  86.     register int      len;
  87. {
  88.     int           len1;
  89.     int           len2;
  90.     char        * rtn;
  91.  
  92.     malloc_check_strn("strncat", str2, len);
  93.  
  94.     malloc_checking = 1;
  95.  
  96.     len2 = strlen(str2) + 1;
  97.     len1 = strlen(str1);
  98.  
  99.     malloc_checking = 0;
  100.  
  101.  
  102.     if( (len+1) < len2 )
  103.     {
  104.         len1 += len + 1;
  105.     }
  106.     else
  107.     {
  108.         len1 += len2;
  109.     }
  110.     malloc_check_data("strncat", str1, len1);
  111.  
  112.     rtn = str1;
  113.  
  114.     while( *str1 )
  115.     {
  116.         str1++;
  117.     }
  118.  
  119.     while( len-- && ((*str1++ = *str2++) != '\0') )
  120.     {
  121.     }
  122.     
  123.     if( ! len )
  124.     {
  125.         *str1 = '\0';
  126.     }
  127.  
  128.     return(rtn);
  129. }
  130.  
  131. int
  132. strcmp(str1,str2)
  133.     register char    * str1;
  134.     register char    * str2;
  135. {
  136.     malloc_check_str("strcmp", str1);
  137.     malloc_check_str("strcmp", str2);
  138.  
  139.     while( *str1 && (*str1 == *str2) )
  140.     {
  141.         str1++;
  142.         str2++;
  143.     }
  144.  
  145.  
  146.     /*
  147.      * in order to deal with the case of a negative last char of either
  148.      * string when the other string has a null
  149.      */
  150.     if( (*str2 == '\0') && (*str1 == '\0') )
  151.     {
  152.         return(0);
  153.     }
  154.     else if( *str2 == '\0' )
  155.     {
  156.         return(1);
  157.     }
  158.     else if( *str1 == '\0' )
  159.     {
  160.         return(-1);
  161.     }
  162.     
  163.     return( *str1 - *str2 );
  164. }
  165.  
  166. int
  167. strncmp(str1,str2,len)
  168.     register char    * str1;
  169.     register char    * str2;
  170.     register int      len;
  171. {
  172.     malloc_check_strn("strncmp", str1, len);
  173.     malloc_check_strn("strncmp", str2, len);
  174.  
  175.     while( --len >= 0 && *str1 && (*str1 == *str2) )
  176.     {
  177.         str1++;
  178.         str2++;
  179.     }
  180.  
  181.     if( len < 0 )
  182.     {
  183.         return(0);
  184.     }
  185.     /*
  186.      * in order to deal with the case of a negative last char of either
  187.      * string when the other string has a null
  188.      */
  189.     if( (*str2 == '\0') && (*str1 == '\0') )
  190.     {
  191.         return(0);
  192.     }
  193.     else if( *str2 == '\0' )
  194.     {
  195.         return(1);
  196.     }
  197.     else if( *str1 == '\0' )
  198.     {
  199.         return(-1);
  200.     }
  201.     
  202.     return( *str1 - *str2 );
  203. }
  204.  
  205. char *
  206. strcpy(str1,str2)
  207.     register char    * str1;
  208.     register char    * str2;
  209. {
  210.     char        * rtn;
  211.     int          len;
  212.  
  213.     malloc_checking = 1;
  214.     len = strlen(str2) + 1;
  215.     malloc_checking = 0;
  216.  
  217.     malloc_check_data("strcpy", str1, len);
  218.     malloc_check_data("strcpy", str2, len);
  219.  
  220.     rtn = str1;
  221.  
  222.     while( (*str1++ = *str2++) != '\0')
  223.     {
  224.     }
  225.  
  226.     return(rtn);
  227. }
  228.  
  229. char *
  230. strncpy(str1,str2,len)
  231.     register char    * str1;
  232.     register char    * str2;
  233.     register int      len;
  234. {
  235.     extern int      malloc_checking;
  236.     char        * rtn;
  237.  
  238.     malloc_check_data("strncpy", str1, len);
  239.     malloc_check_strn("strncpy", str2, len);
  240.  
  241.     rtn = str1;
  242.  
  243.     while((len-- > 0) && (*str1++ = *str2++) != '\0')
  244.     {
  245.     }
  246.     while( (len-- > 0) )
  247.     {
  248.         *str1++ = '\0';
  249.     }
  250.  
  251.     return(rtn);
  252. }
  253.  
  254. int
  255. strlen(str1)
  256.     register char    * str1;
  257. {
  258.     register char    * s;
  259.  
  260.     if(! malloc_checking )
  261.     {
  262.         malloc_check_str("strlen", str1);
  263.     }
  264.  
  265.     for( s = str1; *s; s++)
  266.     {
  267.     }
  268.  
  269.     return( s - str1 );
  270. }
  271.  
  272. char *
  273. strchr(str1,c)
  274.     register char    * str1;
  275.     register int      c;
  276. {
  277.     malloc_check_str("strchr", str1);
  278.  
  279.     while( *str1 && (*str1 != (char) c) )
  280.     {
  281.         str1++;
  282.     }
  283.  
  284.     if(*str1 != (char) c)
  285.     {
  286.         str1 = (char *) 0;
  287.     }
  288.  
  289.     return(str1);
  290. }
  291.  
  292. char *
  293. strrchr(str1,c)
  294.     register char    * str1;
  295.     register int      c;
  296. {
  297.     register char    * rtn = (char *) 0;
  298.  
  299.     malloc_check_str("strrchr", str1);
  300.  
  301.     while( *str1 )
  302.     {
  303.         if(*str1 == (char) c )
  304.         {
  305.             rtn = str1;
  306.         }
  307.         str1++;
  308.     }
  309.  
  310.     if( *str1 == (char) c)
  311.     {
  312.         rtn = str1;
  313.     }
  314.  
  315.     return(rtn);
  316. }
  317.  
  318. char *
  319. index(str1,c)
  320.     char        * str1;
  321.     char          c;
  322. {
  323.     return( strchr(str1,c) );
  324. }
  325.  
  326. char *
  327. rindex(str1,c)
  328.     char        * str1;
  329.     char          c;
  330. {
  331.     return( strrchr(str1,c) );
  332. }
  333.  
  334. char *
  335. strpbrk(str1,str2)
  336.     register char    * str1;
  337.     register char    * str2;
  338. {
  339.     register char    * tmp;
  340.  
  341.     malloc_check_str("strpbrk", str1);
  342.     malloc_check_str("strpbrk", str2);
  343.  
  344.     while(*str1)
  345.     {
  346.         for( tmp=str2; *tmp && *tmp != *str1; tmp++)
  347.         {
  348.         }
  349.         if( *tmp )
  350.         {
  351.             break;
  352.         }
  353.         str1++;
  354.     }
  355.  
  356.     if( ! *str1 )
  357.     {
  358.         str1 = (char *) 0;
  359.     }
  360.  
  361.     return(str1);
  362. }
  363.  
  364. int
  365. strspn(str1,str2)
  366.     register char    * str1;
  367.     register char    * str2;
  368. {
  369.     register char    * tmp;
  370.     char        * orig = str1;
  371.  
  372.     malloc_check_str("strspn", str1);
  373.     malloc_check_str("strspn", str2);
  374.  
  375.     while(*str1)
  376.     {
  377.         for( tmp=str2; *tmp && *tmp != *str1; tmp++)
  378.         {
  379.         }
  380.         if(! *tmp )
  381.         {
  382.             break;
  383.         }
  384.         str1++;
  385.     }
  386.  
  387.     return( (int) (str1 - orig) );
  388. }
  389.  
  390. int
  391. strcspn(str1,str2)
  392.     register char    * str1;
  393.     register char    * str2;
  394. {
  395.     register char    * tmp;
  396.     char        * orig = str1;
  397.  
  398.     malloc_check_str("strcspn", str1);
  399.     malloc_check_str("strcspn", str2);
  400.  
  401.     while(*str1)
  402.     {
  403.         for( tmp=str2; *tmp && *tmp != *str1; tmp++)
  404.         {
  405.         }
  406.         if( *tmp )
  407.         {
  408.             break;
  409.         }
  410.         str1++;
  411.     }
  412.  
  413.     return( (int) (str1 - orig) );
  414. }
  415.  
  416. /*
  417.  * strtok() source taken from that posted to comp.lang.c by Chris Torek
  418.  * in Jan 1990.
  419.  */
  420.  
  421. /*
  422.  * Copyright (c) 1989 The Regents of the University of California.
  423.  * All rights reserved.
  424.  *
  425.  * Redistribution and use in source and binary forms are permitted
  426.  * provided that the above copyright notice and this paragraph are
  427.  * duplicated in all such forms and that any documentation,
  428.  * advertising materials, and other materials related to such
  429.  * distribution and use acknowledge that the software was developed
  430.  * by the University of California, Berkeley.  The name of the
  431.  * University may not be used to endorse or promote products derived
  432.  * from this software without specific prior written permission.
  433.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  434.  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  435.  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  436.  */
  437.  
  438. /*
  439.  * Get next token from string s (NULL on 2nd, 3rd, etc. calls),
  440.  * where tokens are nonempty strings separated by runs of
  441.  * chars from delim.  Writes NULs into s to end tokens.  delim need not
  442.  * remain constant from call to call.
  443.  *
  444.  * Modified by cpc:     changed variable names to conform with naming
  445.  *            conventions used in rest of code.  Added malloc pointer
  446.  *            check calls.
  447.  */
  448. char *
  449. strtok(str1, str2)
  450.     char     * str1;
  451.     char    * str2;
  452. {
  453.     static char     * last;
  454.     char        * strtoken();
  455.  
  456.     if( str1 )
  457.     {
  458.         malloc_check_str("strtok", str1);
  459.         last = str1;
  460.     }
  461.     malloc_check_str("strtok", str2);
  462.  
  463.     return (strtoken(&last, str2, 1));
  464. }
  465.  
  466.  
  467. /*
  468.  * Get next token from string *stringp, where tokens are (possibly empty)
  469.  * strings separated by characters from delim.  Tokens are separated
  470.  * by exactly one delimiter iff the skip parameter is false; otherwise
  471.  * they are separated by runs of characters from delim, because we
  472.  * skip over any initial `delim' characters.
  473.  *
  474.  * Writes NULs into the string at *stringp to end tokens.
  475.  * delim will usually, but need not, remain constant from call to call.
  476.  * On return, *stringp points past the last NUL written (if there might
  477.  * be further tokens), or is NULL (if there are definitely no more tokens).
  478.  *
  479.  * If *stringp is NULL, strtoken returns NULL.
  480.  */
  481. char *
  482. strtoken(stringp, delim, skip)
  483.     register char **stringp;
  484.     register char *delim;
  485.     int skip;
  486. {
  487.     register char *s;
  488.     register char *spanp;
  489.     register int c, sc;
  490.     char *tok;
  491.  
  492.     if ((s = *stringp) == NULL)
  493.         return (NULL);
  494.  
  495.     if (skip) {
  496.         /*
  497.          * Skip (span) leading delimiters (s += strspn(s, delim)).
  498.          */
  499.     cont:
  500.         c = *s;
  501.         for (spanp = delim; (sc = *spanp++) != 0;) {
  502.             if (c == sc) {
  503.                 s++;
  504.                 goto cont;
  505.             }
  506.         }
  507.         if (c == 0) {        /* no token found */
  508.             *stringp = NULL;
  509.             return (NULL);
  510.         }
  511.     }
  512.  
  513.     /*
  514.      * Scan token (scan for delimiters: s += strcspn(s, delim), sort of).
  515.      * Note that delim must have one NUL; we stop if we see that, too.
  516.      */
  517.     for (tok = s;;) {
  518.         c = *s++;
  519.         spanp = delim;
  520.         do {
  521.             if ((sc = *spanp++) == c) {
  522.                 if (c == 0)
  523.                     s = NULL;
  524.                 else
  525.                     s[-1] = 0;
  526.                 *stringp = s;
  527.                 return (tok);
  528.             }
  529.         } while (sc != 0);
  530.     }
  531.     /* NOTREACHED */
  532. }
  533.  
  534. /*
  535.  * $Log: string.c,v $
  536.  * Revision 1.1  1992/01/24  03:29:13  dvadura
  537.  * dmake Version 3.8, Initial revision
  538.  *
  539.  * Revision 1.7  90/08/29  22:24:19  cpcahil
  540.  * added new function to check on strings up to a specified length 
  541.  * and used it within several strn* functions.
  542.  * 
  543.  * Revision 1.6  90/07/16  20:06:56  cpcahil
  544.  * fixed several minor bugs found with Henry Spencer's string/mem function
  545.  * tester program.
  546.  * 
  547.  * Revision 1.5  90/06/10  14:59:49  cpcahil
  548.  * Fixed a couple of bugs in strncpy & strdup
  549.  * 
  550.  * Revision 1.4  90/05/11  00:13:10  cpcahil
  551.  * added copyright statment
  552.  * 
  553.  * Revision 1.3  90/02/24  21:50:32  cpcahil
  554.  * lots of lint fixes
  555.  * 
  556.  * Revision 1.2  90/02/24  17:29:40  cpcahil
  557.  * changed $Header to $Id so full path wouldnt be included as part of rcs 
  558.  * id string
  559.  * 
  560.  * Revision 1.1  90/02/22  23:17:44  cpcahil
  561.  * Initial revision
  562.  * 
  563.  */
  564.